Mega Pi Control System

This document is used to describe the installation and use of the Mega mBot control system. Please use the following quick links to a specific section. Note that the system is developed in Python, so all examples in this document are coded in Python.

Installation and Setup

1.) Please download client.zip and server.zip, and save them to your local file system.

2.) If planning to use the desktop as the client host (not recommended, a Raspberry Pi host is prefered), a Linux based installation is required, as some modules used are not compatible with Windows and MacOS installations.

Initial setup

A Raspberry Pi is mounted on top of a Mega mBot. Generally speaking, server.py runs on the Raspberry Pi and is used to control the mobility, communication, and computation of the Mega Pi. Hence, this section will show how to install Raspberry Pi OS on a new Raspberry Pi and set it up via SSH.

1.) Download a Legacy installation (Buster) of Raspberry Pi Lite OS from here. It is recommended to download Raspberry Pi OS Lite.

2.) Download balenaEtcher from here, which is OS Image Flasher for SD Cards and USB Drives.

3.) Install Raspberry Pi OS to the SD card of Raspberry Pi via balenaEtcher.

etcher

4.) Insert the SD card back into the Raspberry Pi and connect the Raspberry Pi to the internet via an ethernet cable.

6.) Connect via ssh with username pi to the IP address (e.g., 192.168.1.237) you found in step 6. The default password is raspberry.

Note that the command for Numpy is different depending on version of Python. use the python3 command for 3, or python for 2.7.

To make sure that the iPerf latency testing can be used, make sure to install the below files. Note that only 2 pis can use iPerf3 at a time, as muliple nodes are not supported.

Client

1.) The first option connects to all Mega mBots in your network, which means as long as your Mega mBot (running server.py) is connected to the same network as your client, you can send instructions to all Mega mBots synchronously. This is useful when you want all Mega mBots to perform the same mobility moves as well as distribute computing tasks.

2.) The second option only connects to a single Mega mBot, which is useful when you want to test instructions.

Available Control Instructions

Server

On the server side (Raspberry Pi on the top of Mega mBot), you can run the server.py as follows:

Configuration

The config.txt file is the configuration file that used to set up the server. The most important things in this file are the host IP address and port settings. Here is the default settings:

config

mBotMega Module

The class mBotMega in lib/mbot.py is the interface that provides methods to control the mobility of a Mega mBot. When you look at the code, each method is well commented for the parameters.

Now, when you trigger the front IR proximity sensor, the Mega mBot will move backwards, and when you trigger the back impact switches, the Mega mBot will perform a different series of movements. Lastly, when you are done with the testing, you should stop the execution of this mobility firmware by:

Custom Mobility Controls

As you have already seen the mobility control example at the section mBotMega Module, it is possible to create custom mobility firmware to be installed at each Mega mBot. To create such firmware, you need firstly create a Mobility class in a new Python file. Once you have the Mobility class, you have to include a __init__ method that must contain exactly one parameter to which an instance of mBotMega Module will be passed. Lastly, the Mobility class must include a run method, which is executed when the client trigger the mobility firmware. In addition, if you want to import any module in the mobility firmware, you must import inside the run method. Otherwise, it won't work. Here is a sample template:

class Mobility:
  def __init__(self, mbot):
    self.mbot = mbot

  def run(self):
    from time import sleep
    while(1):

      # Your code continue here

      sleep(1)

Setting Up Different Methods

Note that there are currently three(four if including ROS) methods of controlling the Mega Pi systems as a group.
Method 1 - Network Sockets This is the simplest method to use the Mbots together, although it is slower than MPI, and a network is required, so places without a LAN network are incompatible.
sudo chgrp blutooth /var/run/sdp Method 2 - Bluetooth Sockets The solution to using sockets outside of a LAN network is using Bluetooth, although the downside here is that there is inevitably a minor amount of latency due to the use case of bluetooth. Usually this will be a negligible difference, but over larger data sizes, it will cause an impact. The upside is that bluetooth connection is possible without a LAN network, making it deployable anywhere.
Method 3- MPI (Message Passing Interface) MPI, or Message Passing Interface, is the quickest of the three methods, being able to compute tasks at considerably faster times. The downside is the difficulty to program tasks in this method, as some form of knowledge of MPI is required. A network of some kind is also required

Setting up bluetooth

If you want to use the bluetooth server and client file you follow the steps below to install and setup the necessary blutooth parts. Using the btclient.py and btserver.py files functions identical to that of the LAN network version.

2.) At the bottom bottom and change enable-uart to 1, and add dtoverlay=pi3-miniuart-bt

5.) This could break after updates, so make sure it doesn't by editting the override file as follows

5.5) Note that on restarts, the bluetooth may need to be restarted with the following command. This is just a quirk of the Raspberry Pi with mini-uart unfortunately

Installing mpi4py

One of the other methods used is MPI (Message Passing Interface), for this we are using MPICH and mpi4py on the Raspberry Pi. There are plenty of good tutorials online, such as this installation. However, we will also go over it here.

1.) Change the name of all Pis being used under Advanced Options. For example, we used Pi1, Pi2, Pi3,etc. You can also use "master", slave1,slave2, etc, or whatever will be easy to remember.

2.) Setup passwordless ssh so that there is no conflict when attempting to use multiple machines.

3.) On each Pi, the /etc/hosts file needs to have the hostname and IP of the others, so,

3.5.) Add the following below the other text, where "node IP" is the IP of a Pi, and "hostname" is the name given on that Pi

5.) Along with the host file, a machinefile is required to hold the IPs being used by mpi. This is done by simply writing the IPs or hostnames in a file titled machinefile where you want to run a program. This must be in the same folder as where you are running the mpiexec command. Alternatively, you can simply point to its location with "./foldername/machinefile"

6.) Try the hostname command with the machine file. If everything is set up properly on each Pi, the name given to each IP will be printed to the screen.

Installing ROS Noetic

Custom Tasks and how to use them

Custom Tasks

It is also possible to create custom tasks and distribute each sub-task to each connected Mega mBots and later reconstruct the result of each sub-task. To do this, there two steps:

1.) On the client side, create a function task in a new Python file. This file is used for each Mega mBot to compute the sub-task distributed to it. Hence, it must contain only one parameter, which is used to pass the data assigned to it. Once the computation is done, it must return the result, which will later be collected and reconstructed on the client (a.k.a. the master node). Similar to the run method inside the Mobility class, if you want to import any module, you must import inside this task function. Here is example of computing uncoded convolution:

def task(data):
  import numpy as np
  s = data[0]
  A = data[1:1+s]
  X = data[1+s:]
  rs = np.convolve(A, X)
  return rs

2.) On the client side again (which is also the master node), you should edit the code on ./master.py for data decomposition, result reconstruction, and ways to get useful information of the task. This means you must have at least three functions: data_decompose, reconstruct and get_information. The first function data_decompose is used to decompose data into small piece and prepare to send to each connect Mega mBot, and it has two parameters. The number of connected Mega mBots passed by the first parameter, and the state (communication and computation latency) per Mega mBot is passed by the second parameter. The second function reconstruct is used to reconstruct results return by Mega mBots. Thus, it has only one parameter, which is used to pass the results. The get_information function is used to return useful information of the task (e.g., size of A), and it is okay to return None if the needed information is pre-stored in data_decompose and reconstruct. The following is the example of data decomposition and result reconstruction for uncoded convolution:

import math
import numpy as np

def data_decompose(proc_num, state = None):
  size_of_A, size_of_X = (40000, 20000)
  s = int(math.sqrt((size_of_A * size_of_X) / proc_num))

  np.random.seed(35)
  A = np.random.randint(1000, size=size_of_A).tolist()
  X = np.random.randint(1000, size=size_of_X).tolist()

  iter1 = int(size_of_A / s)
  iter2 = int(size_of_X / s)

  data_list = []
  for i in range(0, iter1):
    for j in range(0, iter2):
      data = [s]
      data += A[i * s:(i + 1) * s]
      data += X[j * s:(j + 1) * s]
      data_list.append(data)

  return data_list

def reconstruct(data_list):
  proc_num = len(data_list)
  size_of_A, size_of_X = (40000, 20000)
  s = int(math.sqrt((size_of_A * size_of_X) / proc_num))

  iter1 = int(size_of_A / s)
  iter2 = int(size_of_X / s)

  n_A = s + size_of_X - 1
  n_Z = len(data_list[0])

  result = []
  for i in range(0, iter1):
    data = []
    partial_result = [0 for i in range(0, n_A)]
    for j in range(0, iter2):
      padding_left = s * j
      padding_right = n_A - n_Z - s * j
      data_temp = data_list[i*iter2+j]
      data_temp = np.pad(data_temp, (padding_left, padding_right), 'constant')
      data.append(data_temp)
    for d in data:
      partial_result = np.add(partial_result, d)
    result.append(partial_result)

  n = size_of_A + size_of_X - 1
  n_Z = len(result[0])

  data = []
  final_result = [0 for i in range(0, n)]
  for j in range(0, len(result)):
    padding_left = s * j
    padding_right = n - n_Z - s * j
    data_temp = np.pad(result[j], (padding_left, padding_right), 'constant')
    data.append(data_temp)

  for d in data:
    final_result = np.add(final_result, d)

  # return final_result
  return np.round(final_result).astype(int)

def get_information():
  pass

Note: If the data returned by the data_decompose function is in numpy array format, be sure to convert it to a list through .tolist().

Mega mBot Control System and Installation Doc